home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Aminet 5
/
Aminet 5 - March 1995.iso
/
Aminet
/
dev
/
c
/
agl103p.lha
/
src
/
agl
/
poly.c
< prev
next >
Wrap
C/C++ Source or Header
|
1994-12-08
|
10KB
|
469 lines
/******************************************************************************
Copyright © 1994 Jason Weber
All Rights Reserved
$Id: poly.c,v 1.2.1.5 1994/12/09 05:29:56 jason Exp $
$Log: poly.c,v $
* Revision 1.2.1.5 1994/12/09 05:29:56 jason
* uses global screen settings instead of structure
*
* Revision 1.2.1.4 1994/11/16 06:25:54 jason
* adjust for borders
*
* Revision 1.2.1.3 1994/09/13 03:51:13 jason
* PolyDraw() test
*
* Revision 1.2.1.2 1994/04/06 02:41:16 jason
* Back to rectangular clear
*
* Revision 1.2.1.1 1994/03/29 05:41:32 jason
* Added RCS Header
*
* Revision 1.2.1.1 2002/03/26 22:04:19 jason
* Added RCS Header
*
* Revision 1.2.1.1 2002/03/26 22:00:51 jason
* RCS/agl.h,v
*
******************************************************************************/
#ifndef NOT_EXTERN
#include"agl.h"
#endif
#define POLYLINE FALSE /* use PolyDraw() instead of Move(), Draw() */
#define MAX_LINE_VERTS 512 /* max # of lines vertices (2 times max lines) */
short LineBuffer[MAX_LINE_VERTS];
/******************************************************************************
void recti(long x1,long y1,long x2,long y2)
******************************************************************************/
/*PROTOTYPE*/
void recti(long x1,long y1,long x2,long y2)
{
bgnline();
rectvert((float)x1,(float)y1,(float)x2,(float)y2,TRUE);
endline();
}
/******************************************************************************
void rectfi(long x1,long y1,long x2,long y2)
******************************************************************************/
/*PROTOTYPE*/
void rectfi(long x1,long y1,long x2,long y2)
{
if(OneToOne[CurrentWid]) /* bypass transforms if no effect */
{
y1=CurrentHeight-y1-1;
y2=CurrentHeight-y2-1;
RectFill(DrawRPort,x1,y2,x2,y1);
return;
}
bgnpolygon();
rectvert((float)x1,(float)y1,(float)x2,(float)y2,FALSE);
endpolygon();
}
/******************************************************************************
void rects(short x1,short y1,short x2,short y2)
******************************************************************************/
/*PROTOTYPE*/
void rects(short x1,short y1,short x2,short y2)
{
bgnline();
rectvert((float)x1,(float)y1,(float)x2,(float)y2,TRUE);
endline();
}
/******************************************************************************
void rectfs(short x1,short y1,short x2,short y2)
******************************************************************************/
/*PROTOTYPE*/
void rectfs(short x1,short y1,short x2,short y2)
{
bgnpolygon();
rectvert((float)x1,(float)y1,(float)x2,(float)y2,FALSE);
endpolygon();
}
/******************************************************************************
void rect(float x1,float y1,float x2,float y2)
******************************************************************************/
/*PROTOTYPE*/
void rect(float x1,float y1,float x2,float y2)
{
bgnline();
rectvert(x1,y1,x2,y2,TRUE);
endline();
}
/******************************************************************************
void rectf(float x1,float y1,float x2,float y2)
******************************************************************************/
/*PROTOTYPE*/
void rectf(float x1,float y1,float x2,float y2)
{
bgnpolygon();
rectvert(x1,y1,x2,y2,FALSE);
endpolygon();
}
/******************************************************************************
void rectvert(float x1,float y1,float x2,float y2,long line)
******************************************************************************/
/*PROTOTYPE*/
void rectvert(float x1,float y1,float x2,float y2,long line)
{
static float vert[4][2];
short n;
vert[0][0]=x1;
vert[0][1]=y1;
vert[1][0]=x2;
vert[1][1]=y1;
vert[2][0]=x2;
vert[2][1]=y2;
vert[3][0]=x1;
vert[3][1]=y2;
for(n=0;n<4;n++)
v2f(vert[n]);
if(line)
v2f(vert[0]);
}
/*******************************************************************************
void bgnpoint(void)
*******************************************************************************/
/*PROTOTYPE*/
void bgnpoint(void)
{
if(DrawType)
GL_error("bgnpoint(): bad command order");
DrawType=GL_POINT;
}
/*******************************************************************************
void endpoint(void)
*******************************************************************************/
/*PROTOTYPE*/
void endpoint(void)
{
if(DrawType!=GL_POINT)
GL_error("endpoint(): bad command order");
DrawType=FALSE;
}
/*******************************************************************************
void bgnline(void)
*******************************************************************************/
/*PROTOTYPE*/
void bgnline(void)
{
if(DrawType)
GL_error("bgnline(): bad command order");
DrawType=GL_LINE;
BgnLine=TRUE;
Verts=0;
}
/*******************************************************************************
void endline(void)
*******************************************************************************/
/*PROTOTYPE*/
void endline(void)
{
if(DrawType!=GL_LINE)
GL_error("endline(): bad command order");
#if POLYLINE
else
PolyDraw(DrawRPort,Verts/2,LineBuffer);
#endif
DrawType=FALSE;
}
/*******************************************************************************
void bgnpolygon(void)
*******************************************************************************/
/*PROTOTYPE*/
void bgnpolygon(void)
{
if(DrawType)
GL_error("bgnpolygon(): bad command order");
DrawType=GL_POLYGON;
Verts=0;
}
/*******************************************************************************
void endpolygon(void)
*******************************************************************************/
/*PROTOTYPE*/
void endpolygon(void)
{
if(DrawType!=GL_POLYGON)
GL_error("endpolygon(): bad command order");
AreaEnd(DrawRPort);
DrawType=FALSE;
}
/*******************************************************************************
void render_vertex(short vert[2])
*******************************************************************************/
/*PROTOTYPE*/
void render_vertex(short vert[2])
{
long x,y;
x=vert[0];
y=CurrentHeight-vert[1]-1;
if(Bordered[CurrentWid])
{
x+=BorderWidth;
y+=BorderWidth+BorderHeight;
}
switch(DrawType)
{
case FALSE:
GL_error("v??(): bad command order");
break;
case GL_POINT:
WritePixel(DrawRPort,x,y);
break;
case GL_LINE:
#if POLYLINE
if(Verts==MAX_LINE_VERTS)
GL_error("Exceeded max points in polyline");
else
{
LineBuffer[Verts++]=x;
LineBuffer[Verts++]=y;
}
#else
if(BgnLine)
{
BgnLine=FALSE;
Move(DrawRPort,x,y);
}
else
Draw(DrawRPort,x,y);
#endif
break;
case GL_POLYGON:
if(Verts==MAX_POLY_VERTS)
GL_error("Exceeded max points in polygon");
else
{
if(Verts)
AreaDraw(DrawRPort,x,y);
else
AreaMove(DrawRPort,x,y);
Verts++;
}
break;
}
}
/******************************************************************************
void mapcolor(long m,long r,long g,long b)
maintain 256 shade standard
******************************************************************************/
/*PROTOTYPE*/
void mapcolor(long m,long r,long g,long b)
{
char string[100];
if(m<0 || m>15)
{
sprintf(string,"mapcolor(): bad index %d",m);
GL_error(string);
return;
}
r=(r+7)/16;
g=(g+7)/16;
b=(b+7)/16;
ColorMap[m]= (((r<<4)+g)<<4)+b;
SetRGB4(GLView,m,r,g,b);
}
/******************************************************************************
void getmcolor(long m,long *r,long *g,long *b)
******************************************************************************/
/*PROTOTYPE*/
void getmcolor(long m,long *r,long *g,long *b)
{
*r=ColorMap[m];
*b= *r&15;
*r= *r>>4;
*g= *r&15;
*r= *r>>4;
*r *=16;
*g *=16;
*b *=16;
}
/*******************************************************************************
void color(long c)
*******************************************************************************/
/*PROTOTYPE*/
void color(long c)
{
CurrentColor=c;
SetAPen(DrawRPort,c);
}
/*******************************************************************************
long getcolor(void)
*******************************************************************************/
/*PROTOTYPE*/
long getcolor(void)
{
return CurrentColor;
}
/*******************************************************************************
void clear(void)
*******************************************************************************/
/*PROTOTYPE*/
void clear(void)
{
long bit,value;
long m,line,screenwidth,offset,lineoff;
size_t linewidth;
PLANEPTR planes,planem;
/* only activate one of the following three methods */
#if FALSE
/* clear window */
RectFill(DrawRPort,0,0,CurrentWidth-1,CurrentHeight-1);
#endif
#if TRUE
/* clear whole screen (clipped to window) */
SetRast(DrawRPort,CurrentColor);
#endif
#if FALSE
size=ScreenWidth*ScreenHeight/8;
/* individually clear each full plane */
for(m=0;m<ScreenDeep;m++)
memset(DrawRPort->BitMap->Planes[m],2<<m,size);
#endif
#if FALSE
screenwidth=ScreenWidth/8+1;
offset=screenwidth*(ScreenHeight-CurrentPosY-CurrentHeight-1)+CurrentPosX/8;
linewidth=(CurrentWidth+7)/8+1;
bit=1;
if(offset)
{
offset--;
linewidth++;
}
/* individually clear area in each plane */
for(m=0;m<ScreenDeep;m++)
{
if(CurrentColor&bit)
value=255;
else
value=0;
lineoff=offset;
planem= (DrawRPort->BitMap->Planes[m]);
for(line=0;line<CurrentHeight;line++)
{
memset(&(planem[lineoff]),value,linewidth);
lineoff+=screenwidth;
}
bit<<=1;
}
/*
BltClear((DrawRPort->BitMap->Planes[m])+offset,size,0);
*/
#endif
}